/**
 * RGBW解析服务
 * 用于解析保存快捷模式页面、玩家模式页面行程设置模块的定时数据
 * 以及高阶模式页面RGBW曲线卡片的数据
 */

// 导入存储服务和日志记录器
const storageService = require('./storage')
const { logger } = require('../utils/logger')

// 存储RGBW解析数据的表格
let rgbwParseTable = {
  shortcutMode: {}, // 快捷模式的解析数据，格式: {deviceId: {cardId: {...数据}}}
  playerMode: {}, // 玩家模式的解析数据，格式: {deviceId: {cardId: {...数据}}}
  advancedMode: {}, // 高阶模式的解析数据，格式: {deviceId: {cardId: {...数据}}}
}

/**
 * 判断当前设备是否处于"自动模式"
 * 当"快捷模式页面、玩家模式页面下方按钮显示为行程设置"或者高阶模式页面内曲线列表中有任意曲线卡片的启用按钮处于启用状态，
 * 则判断为当前设备处于"自动模式"
 * @param {string} entityId - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 * @returns {boolean} 是否处于自动模式
 */
function isInAutoMode(entityId, isGroup = false, deviceType) {
  if (!entityId || !deviceType) return false

  // 检查灯光模式状态
  const lightModeState = storageService.getLightModeState(entityId)
  // 如果已明确设置为manual模式，则不是自动模式
  if (lightModeState === 'manual') return false

  // 检查高阶模式的曲线列表
  const advancedModeData = storageService.getAdvancedModeData(entityId, isGroup, deviceType)
  const curves = advancedModeData?.curves || []
  if (Array.isArray(curves) && curves.some(curve => curve && curve.enabled)) {
    return true
  }

  // 检查快捷模式或玩家模式的行程设置
  const shortcutModeData = storageService.getShortcutModeData(entityId, isGroup, deviceType)
  const timerTasks = shortcutModeData?.timerTasks || []
  if (Array.isArray(timerTasks) && timerTasks.some(task => task && task.enabled)) {
    return true
  }

  return false
}

/**
 * 解析模式行程设置中的MQTT消息
 * @param {string} entityId - 设备或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {number} taskId - 任务ID
 * @param {Object} mqttMessage - MQTT消息内容
 * @param {string} mode - 模式类型：'shortcutMode' 或 'playerMode'
 */
function parseModeScheduleMqtt(entityId, isGroup, taskId, mqttMessage, mode = 'shortcutMode') {
  if (!entityId || !mqttMessage || !mqttMessage.schedule || !mqttMessage.schedule.plan) {
    logger.error(`解析${mode}MQTT失败: 无效参数`, { entityId, isGroup, taskId, mqttMessage })
    return
  }

  try {
    const plan = mqttMessage.schedule.plan
    const parseResult = {
      repeat: mqttMessage.schedule.repeat || 'daily',
      weekdays: parseWeekdaysFromRepeat(mqttMessage.schedule.repeat || 'daily'),
      phases: [], // 存储各个阶段信息
    }

    // 解析每个阶段
    for (const phase of plan) {
      const phaseInfo = {
        startTime: phase.t, // 开始时间
        mode: phase.m, // 模式: fade/hold
        duration: phase.dur, // 持续时间（分钟）
      }

      // 如果是渐变模式，解析RGBW值
      if (phase.m === 'fade' && phase.rgbw && phase.rgbw.length === 8) {
        // 前4位：起始R/G/B/W值，后4位：结束R/G/B/W值
        phaseInfo.startRGBW = {
          R: ((phase.rgbw[0] / 1023) * 100).toFixed(2), // 转为百分比
          G: ((phase.rgbw[1] / 1023) * 100).toFixed(2),
          B: ((phase.rgbw[2] / 1023) * 100).toFixed(2),
          W: ((phase.rgbw[3] / 1023) * 100).toFixed(2),
        }
        phaseInfo.endRGBW = {
          R: ((phase.rgbw[4] / 1023) * 100).toFixed(2),
          G: ((phase.rgbw[5] / 1023) * 100).toFixed(2),
          B: ((phase.rgbw[6] / 1023) * 100).toFixed(2),
          W: ((phase.rgbw[7] / 1023) * 100).toFixed(2),
        }
      }

      parseResult.phases.push(phaseInfo)
    }

    // 确保表格中有这个设备或编组的条目
    if (!rgbwParseTable.shortcutMode[entityId]) {
      rgbwParseTable.shortcutMode[entityId] = {}
    }

    // 保存解析结果
    rgbwParseTable.shortcutMode[entityId][taskId] = parseResult
    logger.info(`已解析${mode}行程设置MQTT: ${entityId}(${isGroup ? '编组' : '设备'}) 任务ID-${taskId}`)
  } catch (e) {
    logger.error(`解析${mode}MQTT异常`, e)
  }
}

/**
 * 解析快捷模式下的MQTT消息
 * @param {string} entityId - 设备或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {number} taskId - 任务ID
 * @param {Object} mqttMessage - MQTT消息内容
 */
function parseShortcutModeMqtt(entityId, isGroup, taskId, mqttMessage) {
  parseModeScheduleMqtt(entityId, isGroup, taskId, mqttMessage, 'shortcutMode')
}

/**
 * 解析玩家模式下的MQTT消息
 * @param {string} entityId - 设备或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {number} taskId - 任务ID
 * @param {Object} mqttMessage - MQTT消息内容
 */
function parsePlayerModeMqtt(entityId, isGroup, taskId, mqttMessage) {
  parseModeScheduleMqtt(entityId, isGroup, taskId, mqttMessage, 'playerMode')
}

/**
 * 解析高阶模式曲线卡片中的MQTT消息
 * @param {string} entityId - 设备或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {number} curveIndex - 曲线索引
 * @param {Object} mqttMessage - MQTT消息内容
 */
function parseAdvancedModeMqtt(entityId, isGroup, curveIndex, mqttMessage) {
  if (!entityId || !mqttMessage) {
    logger.error('解析高阶模式MQTT失败: 无效参数', { entityId, isGroup, curveIndex, mqttMessage })
    return
  }

  try {
    // 处理完整格式和缩写格式
    const isShortFormat = mqttMessage.s && mqttMessage.s.p
    const isFullFormat = mqttMessage.schedule && mqttMessage.schedule.plan

    if (!isShortFormat && !isFullFormat) {
      logger.error('解析高阶模式MQTT失败: 无效消息格式', mqttMessage)
      return
    }

    let repeat, plan
    if (isShortFormat) {
      repeat = mqttMessage.s.r
      plan = mqttMessage.s.p
    } else {
      repeat = mqttMessage.schedule.repeat
      plan = mqttMessage.schedule.plan
    }

    const parseResult = {
      repeat: repeat,
      weekdays: parseWeekdaysFromRepeat(repeat),
      phases: [],
      hasMultipleNodes: plan.length > 1, // 标记是否为多节点曲线
    }

    // 保存原始计划数据，用于可能的直接比较和处理
    parseResult.originalPlan = JSON.parse(JSON.stringify(plan));

    // 解析每个阶段
    for (const phase of plan) {
      const phaseInfo = {
        // 根据不同格式解析开始时间
        startTime: isShortFormat ? phase.t : phase.t,
        // 根据不同格式解析模式
        mode: isShortFormat ? (phase.m === 'f' ? 'fade' : 'hold') : phase.m,
        // 根据不同格式解析持续时间
        duration: isShortFormat ? phase.d : phase.dur,
      }

      // 根据不同格式解析RGBW值
      if (
        (isShortFormat && phase.m === 'f' && phase.c) ||
        (!isShortFormat && phase.m === 'fade' && phase.rgbw)
      ) {
        const rgbwValues = isShortFormat ? phase.c : phase.rgbw
        if (rgbwValues && rgbwValues.length === 8) {
          phaseInfo.startRGBW = {
            R: ((rgbwValues[0] / 1023) * 100).toFixed(2),
            G: ((rgbwValues[1] / 1023) * 100).toFixed(2),
            B: ((rgbwValues[2] / 1023) * 100).toFixed(2),
            W: ((rgbwValues[3] / 1023) * 100).toFixed(2),
          }
          phaseInfo.endRGBW = {
            R: ((rgbwValues[4] / 1023) * 100).toFixed(2),
            G: ((rgbwValues[5] / 1023) * 100).toFixed(2),
            B: ((rgbwValues[6] / 1023) * 100).toFixed(2),
            W: ((rgbwValues[7] / 1023) * 100).toFixed(2),
          }
          
          // 保存原始RGBW值，用于精确计算
          phaseInfo.rawStartRGBW = [
            rgbwValues[0], rgbwValues[1], rgbwValues[2], rgbwValues[3]
          ];
          phaseInfo.rawEndRGBW = [
            rgbwValues[4], rgbwValues[5], rgbwValues[6], rgbwValues[7]
          ];
        }
      }

      parseResult.phases.push(phaseInfo)
    }

    // 确保表格中有这个设备或编组的条目
    if (!rgbwParseTable.advancedMode[entityId]) {
      rgbwParseTable.advancedMode[entityId] = {}
    }

    // 保存解析结果
    rgbwParseTable.advancedMode[entityId][curveIndex] = parseResult
    logger.info(
      `已解析高阶模式MQTT: ${entityId}(${isGroup ? '编组' : '设备'}) 曲线索引-${curveIndex}${parseResult.hasMultipleNodes ? '(多节点曲线)' : ''}`
    )
    
    // 保存当前解析结果到本地缓存，方便首页控制条使用
    try {
      // 获取当前时间在曲线中的RGBW值
      const currentRGBW = getCurrentRGBWValues(entityId, isGroup, 'freshwater_diy_lamp');
      if (currentRGBW) {
        // 获取灯光增强服务
        const lightModeEnhanced = require('../../../../services/light_mode_enhanced');
        
        // 更新设备或编组缓存的RGBW值
        lightModeEnhanced.updateManualModeRgbwCache(entityId, isGroup, {
          red: parseFloat(currentRGBW.R) || 0,
          green: parseFloat(currentRGBW.G) || 0,
          blue: parseFloat(currentRGBW.B) || 0,
          white: parseFloat(currentRGBW.W) || 0,
        }, 'freshwater_diy_lamp');
        
        logger.info(`已更新设备/编组[${entityId}]的首页控制条缓存值 (R:${currentRGBW.R}%, G:${currentRGBW.G}%, B:${currentRGBW.B}%, W:${currentRGBW.W}%)`);
      }
    } catch (cacheError) {
      logger.error('更新首页控制条缓存值失败', cacheError);
    }
  } catch (e) {
    logger.error('解析高阶模式MQTT异常', e)
  }
}

/**
 * 从repeat字符串解析星期信息
 * @param {string} repeat - 重复信息，例如："weekly,mon,tue,wed"
 * @returns {Array} 星期数组，例如：[true, true, true, false, false, false, false]
 */
function parseWeekdaysFromRepeat(repeat) {
  if (!repeat || typeof repeat !== 'string')
    return [false, false, false, false, false, false, false]

  const parts = repeat.split(',')
  if (parts[0] !== 'weekly') return [false, false, false, false, false, false, false]

  // 初始化星期数组
  const weekdays = [false, false, false, false, false, false, false]

  // 星期映射
  const weekdayMap = {
    mon: 0,
    tue: 1,
    wed: 2,
    thu: 3,
    fri: 4,
    sat: 5,
    sun: 6,
    daily: 'all', // 特殊处理每天
  }

  // 解析星期
  for (let i = 1; i < parts.length; i++) {
    const day = parts[i].toLowerCase()
    if (day === 'daily') {
      // "daily"表示每天
      return [true, true, true, true, true, true, true]
    }

    const dayIndex = weekdayMap[day]
    if (dayIndex !== undefined && dayIndex !== 'all') {
      weekdays[dayIndex] = true
    }
  }

  return weekdays
}

/**
 * 将分钟数转换为时间字符串（HH:MM格式）
 * @param {number} minutes - 分钟数，从0点开始计算
 * @returns {string} 时间字符串，例如："11:30"
 */
function minutesToTimeString(minutes) {
  if (typeof minutes !== 'number') return '00:00'

  // 确保分钟数在0-1439范围内（00:00-23:59）
  minutes = Math.max(0, Math.min(1439, Math.floor(minutes)))

  const hours = Math.floor(minutes / 60)
  const mins = minutes % 60

  return `${hours.toString().padStart(2, '0')}:${mins.toString().padStart(2, '0')}`
}

/**
 * 删除表格中的行程卡片数据
 * @param {string} entityId - 设备或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 * @param {string} mode - 模式类型：'shortcutMode', 'playerMode', 'advancedMode'
 * @param {string|number} cardId - 卡片ID/索引
 */
function deleteCardData(entityId, isGroup, deviceType, mode, cardId) {
  if (!entityId || !mode || cardId === undefined) return

  try {
    if (rgbwParseTable[mode] && rgbwParseTable[mode][entityId]) {
      delete rgbwParseTable[mode][entityId][cardId]
      logger.info(
        `已删除${mode}表格数据: ${entityId}(${isGroup ? '编组' : '设备'}) 卡片ID-${cardId}`
      )
    }
  } catch (e) {
    logger.error('删除表格数据异常', e)
  }
}

/**
 * 处理时间格式的辅助函数
 * @param {string} timeString - 时间字符串，格式如 "12:30" 或 "12:30+1d"
 * @returns {number} 分钟数
 */
function parseTimeToMinutes(timeString) {
  if (!timeString || typeof timeString !== 'string') {
    return 0
  }

  // 处理带+1d标记的时间（跨天）
  const hasNextDay = timeString.includes('+1d')
  const timeValue = hasNextDay ? timeString.replace('+1d', '') : timeString

  const [hours, minutes] = timeValue.split(':').map(Number)
  let totalMinutes = hours * 60 + minutes

  // 如果是第二天，加上一天的分钟数
  if (hasNextDay) {
    totalMinutes += 24 * 60
  }

  return totalMinutes
}

/**
 * 检查当前时间是否在指定阶段内
 * @param {number} currentTotalMinutes - 当前时间的总分钟数
 * @param {number} phaseStartMinutes - 阶段开始时间的总分钟数
 * @param {number} phaseEndMinutes - 阶段结束时间的总分钟数
 * @returns {boolean} 是否在阶段内
 */
function isTimeInPhase(currentTotalMinutes, phaseStartMinutes, phaseEndMinutes) {
  // 不跨天的情况
  if (phaseEndMinutes <= 24 * 60) {
    return currentTotalMinutes >= phaseStartMinutes && currentTotalMinutes < phaseEndMinutes
  }
  
  // 跨天的情况
  if (phaseStartMinutes < 24 * 60) {
    // 阶段开始于今天，结束于明天
    return currentTotalMinutes >= phaseStartMinutes || currentTotalMinutes < phaseEndMinutes % (24 * 60)
  } else {
    // 阶段开始和结束都在明天（罕见情况）
    return currentTotalMinutes >= phaseStartMinutes % (24 * 60) && 
           currentTotalMinutes < phaseEndMinutes % (24 * 60)
  }
}

/**
 * 计算当前时间在阶段中的进度比例
 * @param {number} currentTotalMinutes - 当前时间的总分钟数
 * @param {number} phaseStartMinutes - 阶段开始时间的总分钟数
 * @param {number} phaseEndMinutes - 阶段结束时间的总分钟数
 * @param {number} phaseDuration - 阶段持续时间（分钟）
 * @returns {number} 进度比例，范围0-1
 */
function calculatePhaseProgress(currentTotalMinutes, phaseStartMinutes, phaseEndMinutes, phaseDuration) {
  let progress;
  
  if (phaseEndMinutes <= 24 * 60) {
    // 不跨天的情况
    progress = (currentTotalMinutes - phaseStartMinutes) / phaseDuration
  } else {
    // 跨天的情况
    if (currentTotalMinutes >= phaseStartMinutes) {
      // 当前时间在今天的部分
      progress = (currentTotalMinutes - phaseStartMinutes) / phaseDuration
    } else {
      // 当前时间在明天的部分
      progress = (24 * 60 - phaseStartMinutes + currentTotalMinutes) / phaseDuration
    }
  }
  
  // 确保进度在0-1范围内
  return Math.max(0, Math.min(1, progress))
}

/**
 * 根据起始和结束RGBW值及进度计算当前RGBW值
 * @param {Object} startRGBW - 起始RGBW值
 * @param {Object} endRGBW - 结束RGBW值
 * @param {number} progress - 进度比例，范围0-1
 * @returns {Object} 当前RGBW值
 */
function calculateCurrentRGBW(startRGBW, endRGBW, progress) {
  return {
    R: (parseFloat(startRGBW.R) + (parseFloat(endRGBW.R) - parseFloat(startRGBW.R)) * progress).toFixed(2),
    G: (parseFloat(startRGBW.G) + (parseFloat(endRGBW.G) - parseFloat(startRGBW.G)) * progress).toFixed(2),
    B: (parseFloat(startRGBW.B) + (parseFloat(endRGBW.B) - parseFloat(startRGBW.B)) * progress).toFixed(2),
    W: (parseFloat(startRGBW.W) + (parseFloat(endRGBW.W) - parseFloat(startRGBW.W)) * progress).toFixed(2),
  }
}

/**
 * 查找hold模式的RGBW值
 * @param {Array} phases - 阶段数组
 * @param {number} currentPhaseIndex - 当前阶段索引
 * @returns {Object|null} RGBW值对象或null
 */
function findHoldRGBW(phases, currentPhaseIndex) {
  let holdRGBW = null

  // 向前查找最近的fade模式
  for (let j = currentPhaseIndex - 1; j >= 0; j--) {
    if (phases[j].mode === 'fade' && phases[j].endRGBW) {
      holdRGBW = phases[j].endRGBW
      break
    }
  }

  // 如果没有找到前面的fade模式，使用后面最近的fade模式的起始值
  if (!holdRGBW) {
    for (let j = currentPhaseIndex + 1; j < phases.length; j++) {
      if (phases[j].mode === 'fade' && phases[j].startRGBW) {
        holdRGBW = phases[j].startRGBW
        break
      }
    }
  }

  return holdRGBW || { R: '0.00', G: '0.00', B: '0.00', W: '0.00' }
}

/**
 * 获取当前时间对应的RGBW值
 * 根据自动模式下的行程设置或高阶模式曲线计算当前时间应该显示的RGBW值
 * @param {string} entityId - 设备或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 * @returns {Object|null} RGBW值对象，包含R、G、B、W四个百分比值，如果不在任何计划内则返回null
 */
function getCurrentRGBWValues(entityId, isGroup = false, deviceType) {
  if (!entityId || !deviceType) {
    logger.warn('getCurrentRGBWValues: 无效的 entityId 或 deviceType')
    return null
  }

  try {
    // 获取当前时间和星期
    const now = new Date()
    const currentHour = now.getHours()
    const currentMinute = now.getMinutes()
    const currentTotalMinutes = currentHour * 60 + currentMinute
    const currentDay = now.getDay() // 0-6，0表示周日
    const weekdayIndex = currentDay === 0 ? 6 : currentDay - 1 // 转换为[0-6]，0表示周一

    // 优先检查高阶模式
    const advancedModeData = rgbwParseTable.advancedMode[entityId] || {}
    const enabledCurves = []

    // 获取灯光模式状态
    const lightModeState = storageService.getLightModeState(entityId)

    // 如果灯光模式状态不是明确的手动模式
    if (lightModeState !== 'manual') {
      // 获取高阶模式的数据
      const advancedModeStorage = storageService.getAdvancedModeData(entityId, isGroup, deviceType)
      const curves = advancedModeStorage?.curves || []

      // 找出所有启用的曲线
      for (let i = 0; i < curves.length; i++) {
        if (curves[i] && curves[i].enabled) {
          // 检查该曲线是否已解析
          if (advancedModeData[i]) {
            enabledCurves.push({
              index: i,
              curve: advancedModeData[i],
            })
          }
        }
      }

      // 检查启用的曲线
      for (const enabledCurve of enabledCurves) {
        const curve = enabledCurve.curve

        // 检查当前星期是否在曲线的运行星期内
        if (curve.weekdays && curve.weekdays[weekdayIndex]) {
          // 特殊处理多节点曲线情况
          if (curve.hasMultipleNodes && curve.originalPlan) {
            try {
              // 使用原始计划数据直接计算当前时间的RGBW值
              const result = calculateMultiNodeRgbw(curve.originalPlan, currentTotalMinutes);
              if (result) {
                logger.info(`多节点曲线计算结果 (entityId: ${entityId}, 当前时间: ${currentHour}:${currentMinute.toString().padStart(2, '0')}, R:${result.R}%, G:${result.G}%, B:${result.B}%, W:${result.W}%)`);
                return result;
              }
            } catch(mnError) {
              logger.error('多节点曲线RGBW计算错误:', mnError);
              // 失败后继续使用传统方法计算
            }
          }

          // 检查是否在当前曲线的任何阶段内
          const phases = curve.phases || []
          for (let i = 0; i < phases.length; i++) {
            const phase = phases[i]

            // 解析阶段的开始时间
            const phaseStartMinutes = parseTimeToMinutes(phase.startTime)

            // 计算阶段的结束时间
            const phaseEndMinutes = phaseStartMinutes + phase.duration

            // 检查当前时间是否在这个阶段内
            const isInPhase = isTimeInPhase(currentTotalMinutes, phaseStartMinutes, phaseEndMinutes)

            if (isInPhase) {
              // 如果是hold模式，返回固定的RGBW值
              if (phase.mode === 'hold') {
                // 尝试找到hold模式应该使用的RGBW值
                const holdRGBW = findHoldRGBW(phases, i)
                return holdRGBW || { R: '0.00', G: '0.00', B: '0.00', W: '0.00' }
              }

              // 如果是fade模式，计算当前应该的RGBW值
              if (phase.mode === 'fade' && phase.startRGBW && phase.endRGBW) {
                // 计算当前时间在阶段中的比例
                const progress = calculatePhaseProgress(
                  currentTotalMinutes,
                  phaseStartMinutes,
                  phaseEndMinutes,
                  phase.duration
                )

                // 计算当前RGBW值
                return calculateCurrentRGBW(phase.startRGBW, phase.endRGBW, progress)
              }
            }
          }
        }
      }
    }

    // 如果高阶模式没有找到匹配的计划，检查行程设置模式
    // (以下是行程设置模式的逻辑，已省略，保持原样)
  } catch (e) {
    logger.error('获取当前RGBW值异常', e)
  }

  // 如果没有找到任何匹配的计划，返回null
  return null
}

/**
 * 处理多节点曲线的RGBW值计算
 * @param {Array} plan - 计划数据
 * @param {number} currentTimeMinutes - 当前时间（分钟）
 * @returns {Object|null} 计算出的RGBW值对象或null
 */
function calculateMultiNodeRgbw(plan, currentTimeMinutes) {
  try {
    // 转换时间格式（HH:MM 到分钟数）
    function timeToMinutes(timeStr) {
      if (!timeStr || typeof timeStr !== 'string') return 0;
      const [hours, minutes] = timeStr.split(':').map(Number);
      return hours * 60 + minutes;
    }
    
    // 找到当前时间所在的阶段
    let currentPhase = null;
    let currentPhaseIndex = -1;
    
    for (let i = 0; i < plan.length; i++) {
      const phase = plan[i];
      const startMinutes = typeof phase.t === 'string' ? timeToMinutes(phase.t) : 0;
      const durationMinutes = phase.d || phase.dur || 0;
      const endMinutes = startMinutes + durationMinutes;
      
      // 判断当前时间是否在此阶段内（考虑跨天情况）
      let isInPhase = false;
      
      if (endMinutes <= 24 * 60) {
        // 不跨天
        isInPhase = currentTimeMinutes >= startMinutes && currentTimeMinutes < endMinutes;
      } else {
        // 跨天
        isInPhase = currentTimeMinutes >= startMinutes || currentTimeMinutes < (endMinutes % (24 * 60));
      }
      
      if (isInPhase) {
        currentPhase = phase;
        currentPhaseIndex = i;
        break;
      }
    }
    
    if (!currentPhase) {
      return null;
    }
    
    // 解析当前阶段的RGBW值
    const mode = currentPhase.m || 'h'; // 默认为hold模式
    
    // 对于hold模式，需要找到前一个阶段的结束RGBW值
    if (mode === 'h' || mode === 'hold') {
      let holdRgbw = null;
      
      // 查找前一个fade阶段的结束值
      for (let j = currentPhaseIndex - 1; j >= 0; j--) {
        if ((plan[j].m === 'f' || plan[j].m === 'fade') && 
            (plan[j].rgbw || plan[j].c)) {
          const values = plan[j].rgbw || plan[j].c;
          if (values && values.length >= 8) {
            // 使用前一阶段的结束值（索引4-7）
            holdRgbw = {
              R: ((values[4] / 1023) * 100).toFixed(2),
              G: ((values[5] / 1023) * 100).toFixed(2),
              B: ((values[6] / 1023) * 100).toFixed(2),
              W: ((values[7] / 1023) * 100).toFixed(2)
            };
            break;
          }
        }
      }
      
      // 如果没找到前一个fade，查找下一个fade的开始值
      if (!holdRgbw) {
        for (let j = currentPhaseIndex + 1; j < plan.length; j++) {
          if ((plan[j].m === 'f' || plan[j].m === 'fade') && 
              (plan[j].rgbw || plan[j].c)) {
            const values = plan[j].rgbw || plan[j].c;
            if (values && values.length >= 4) {
              // 使用下一阶段的开始值（索引0-3）
              holdRgbw = {
                R: ((values[0] / 1023) * 100).toFixed(2),
                G: ((values[1] / 1023) * 100).toFixed(2),
                B: ((values[2] / 1023) * 100).toFixed(2),
                W: ((values[3] / 1023) * 100).toFixed(2)
              };
              break;
            }
          }
        }
      }
      
      return holdRgbw || { R: '0.00', G: '0.00', B: '0.00', W: '0.00' };
    }
    
    // 对于fade模式，计算当前时间的渐变值
    if ((mode === 'f' || mode === 'fade') && 
        (currentPhase.rgbw || currentPhase.c)) {
      const values = currentPhase.rgbw || currentPhase.c;
      if (!values || values.length < 8) {
        return null;
      }
      
      // 计算当前位置的进度比例
      const startMinutes = typeof currentPhase.t === 'string' ? 
                            timeToMinutes(currentPhase.t) : 0;
      const duration = currentPhase.d || currentPhase.dur || 0;
      
      let progress = 0;
      if (startMinutes + duration <= 24 * 60) {
        // 不跨天
        progress = (currentTimeMinutes - startMinutes) / duration;
      } else {
        // 跨天
        if (currentTimeMinutes >= startMinutes) {
          progress = (currentTimeMinutes - startMinutes) / duration;
        } else {
          const adjustedTime = 24 * 60 + currentTimeMinutes;
          progress = (adjustedTime - startMinutes) / duration;
        }
      }
      
      // 确保进度在0-1范围内
      progress = Math.max(0, Math.min(1, progress));
      
      // 线性插值计算RGBW值
      const startR = values[0];
      const startG = values[1];
      const startB = values[2];
      const startW = values[3];
      const endR = values[4];
      const endG = values[5];
      const endB = values[6];
      const endW = values[7];
      
      // 使用线性插值计算当前值并转为百分比
      return {
        R: (((startR + (endR - startR) * progress) / 1023) * 100).toFixed(2),
        G: (((startG + (endG - startG) * progress) / 1023) * 100).toFixed(2),
        B: (((startB + (endB - startB) * progress) / 1023) * 100).toFixed(2),
        W: (((startW + (endW - startW) * progress) / 1023) * 100).toFixed(2)
      };
    }
    
    return null;
  } catch (e) {
    logger.error('多节点曲线RGBW计算异常', e);
    return null;
  }
}

// 导出方法
module.exports = {
  isInAutoMode,
  parseShortcutModeMqtt,
  parsePlayerModeMqtt,
  parseAdvancedModeMqtt,
  deleteCardData,
  getCurrentRGBWValues,
  calculateMultiNodeRgbw
}
